package com.zjht.utils;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Eirui
 *
 */
public class MapCacheManager {

    private static final Logger             log        = LoggerFactory.getLogger(MapCacheManager.class);

    private volatile long                   updateTime = 0L;                                            // 更新缓存时记录的时间

    private volatile boolean                updateFlag = true;                                          // 正在更新时的阀门，为false时表示当前没有更新缓存，为true时表示当前正在更新缓存

    private static volatile MapCacheManager mapCacheObject;                                             // 缓存实例对象

    private static Map<String, Object>      cacheMap   = new ConcurrentHashMap<String, Object>();       // 缓存容器


    private MapCacheManager() {
        this.loadCache();// 加载缓存
        updateTime = System.currentTimeMillis();// 缓存更新时间

    }

    /**
     * 采用单例模式获取缓存对象实例
     * 
     * @return This class object
     */
    public static MapCacheManager getInstance() {
        if (null == mapCacheObject) {
            synchronized (MapCacheManager.class) {
                if (null == mapCacheObject) {
                    mapCacheObject = new MapCacheManager();
                }
            }
        }
        return mapCacheObject;
    }

    /**
     * 装载缓存
     */
    private void loadCache() {

        this.updateFlag = true;// 正在更新

        // ********** 数据处理，将数据放入cacheMap缓存中 **begin ******/
        // cacheMap.put("key1", "value1");
        // cacheMap.put("key2", "value2");
        // cacheMap.put("key3", "value3");
        // cacheMap.put("key4", "value4");
        // cacheMap.put("key5", "value5");
        // ********** 数据处理，将数据放入cacheMap缓存中 ***end *******/

        this.updateFlag = false;// 更新已完成

    }

    public void putCache(String keys, Object object) {

        this.updateFlag = true;// 正在更新

        cacheMap.put(keys, object);

        this.updateFlag = false;// 更新已完成

    }

    public Object getCacheObject(String keys) {
        return cacheMap.get(keys);
    }

    public void removeCacheObject(String key) {
        cacheMap.remove(key);
    }

    /**
     * 返回缓存对象
     * 
     * @return
     * @throws Exception
     */
    public Map<String, Object> getMapCache() throws Exception {

        long currentTime = System.currentTimeMillis();
        if (this.updateFlag) {// 前缓存正在更新
            throw new Exception("Cache is Instance .....");
        }

        if (this.IsTimeOut(currentTime)) {// 如果当前缓存正在更新或者缓存超出时限，需重新加载
            synchronized (this) {
                //this.reLoadCache();
                log.info("缓存超时");
                this.updateTime = currentTime;
            }
        }

        return cacheMap;
    }

    private boolean IsTimeOut(long currentTime) {

        return ((currentTime - this.updateTime) > 1000000);// 超过时限，超时
    }

    /**
     * 获取缓存项大小
     * 
     * @return
     */
    public int getCacheSize() {
        return cacheMap.size();
    }

    /**
     * 获取更新时间
     * 
     * @return
     */
    public long getUpdateTime() {
        return this.updateTime;
    }

    /**
     * 获取更新标志
     * 
     * @return
     */
    public boolean getUpdateFlag() {
        return this.updateFlag;
    }

    /**
     * 重新装载
     */
    private void reLoadCache() {
        cacheMap.clear();
        this.loadCache();
    }

}
